#ifndef BASE_DONNEES_H
#   define BASE_DONNEES_H

#include "SDL/SDL.h"

#include "projectiles.h"
#include "ennemis.h"
#include "descriptions.h"
#include "dependances.h"

#include "constantes_et_macros.h"




/**
 * \file base_donnees.h
 * Module permettant de gerer les structures base_donnees.\n
 * Ces structures servent a contenir des informations lues au lancement du
 * programme dans des fichiers textes. Cela permet de ne pas avoir a lire de
 * nouveau ces fichiers par la suite et d'avoir acces rapidement a des
 * informations utiles.\n
 * Les informations en question sont, par exemple, la description de tous les
 * ennemis existants dans le jeu, ou encore la description de tous les objets,
 * des projectiles, etc.
 *
 * Utilisation :
 *
 * 1) Creer la base en recuperant l'adresse renvoyee par creer_base_donnees,
 * qui doit etre appelee sans arguments. Cette fonction fait un malloc et en
 * renvoie le resultat.
 *
 * 2) Remplir la base de donnee avec remplir_base_donnees. Dans le cas
 * contraire, une erreur aura vite fait de se produire, car la base_donnee
 * n'est PAS initialisee lors de sa creation. En effet, ses champs sont
 * initialises avec des mallocs dont la taille depend du contenu des fichiers.
 * On attend donc le remplissage pour faire cette initialisation.
 * En fait, il sagit de tableaux dynamiques, mais
 * aucun ajout d'element ne sera fait une fois le remplissage fini. La taille
 * de ces tableaux est donc fixee une bonne fois pour toute lors de leur
 * initialisation.
 *
 * 3) Utiliser la base de donnee : il est preferable d'utiliser const, car,
 * comme explique ci-dessus, le contenu d'une base_donnees n'est pas destine
 * a etre modifie une fois le remplissage termine.\n
 * Pour acceder aux champs d'une base_donnees de maniere plus claire, il est
 * recommande d'utiliser les accesseurs de ce module (commencant par "get").
 *
 * 4) Detruire la base_donnees avec detruire_base_donnees. Cette fonction
 * appelle toutes les fonctions necessaires a la destruction des champs de la
 * base_donnees, puis fait un free sur la base_donnees elle-meme.
 */




/**
 * \struct base_donnees base_donnees.h
 * Structure qui sera remplie lors du lancement du jeu avec tout ce qui existe
 * et que l'on ne peut se permettre de charger plusieurs fois a partir des
 * fichiers texte (trop couteux)
 */
struct base_donnees
{
    /**
     * attention a ne pas confondre les descriptions d'ennemis et les
     * ennemis de liste_ennemis dans etat_bataille. Quand on parle de
     * description, il n'y a que des informations de bases, tandis que
     * dans l'etat d'une bataille, un ennemi a des points de vie actuels
     * et d'autres donnees de ce type qui ne seraient d'aucune utilite
     * dans ce tableau qui repertorie les profils des differents ennemis
     * du jeu. A noter que le champ id de la structure ennemi fait reference
     * a l'indice dans tab_ennemis auquel on peut trouver l'ennemi
     * correspondant.
     */
    struct tab_dyn_description_ennemis tab_ennemis;
    struct tab_dyn_description_objets tab_objets;
    struct tab_dyn_description_projectiles tab_projectiles;
    /**
     * les paliers d'experience definissent la quantite de points
     * d'experience a amasser pour atteindre chaque niveau.
     * Le niveau maximal est 99. Ce nombre etant constant, nous n'avons pas
     * besoin de faire une allocation dynamique.
     */
    unsigned int paliers_xp[98];
    /**
     * La liste des conditions necessaires pour acceder aux differentes
     * regions. Voir le module dependances pour plus d'informations
     */
    struct tab_dependances dependances;
    /** liste des objets vendus en magasin */
    struct tab_dyn_id objets_en_vente;
    /** liste des quetes du jeu */
    struct tab_dyn_quetes tab_quetes;
    /** liste des regions du jeu */
    struct tab_dyn_regions tab_regions;
    /** ecran est la surface qui sera affichee. */
    surface_jeu* ecran;
    /**
     * les tuiles sont les elements du decor et sont dans un fichier image.
     * Il y en a 10 par ligne et ce sont toutes des carres de 16 pixels de
     * cote. Leurs id fonctionnent ainsi : on va de gauche a droite, ligne
     * par ligne, en augmentant de 1 a chaque fois. Ainsi, la toute premiere
     * est la numero 0, la premiere de la deuxieme ligne est la 10, la 57 sera
     * a la 5eme ligne en 8eme position, etc.
     */
    surface_jeu* tuiles;
    /**
     * sprites_joueur provient du fichier image du meme nom. Les sprites y sont
     * ranges sur une ligne. On y fait reference grace a leur position, en
     * partant de 0. En effet, ils sont tous de al meme taille.
     */
    surface_jeu* sprites_joueur;
    /**
     * Chaque ennemi a sa propre ligne de sprites. Pour eviter a l'utilisateur
     * d'avoir a faire des multiplications par 16, on fait reference a un
     * numero de ligne (la premiere est 0), que le programme multiplie ensuite
     * par 16 pour trouver la coordonnee verticale en nombre de pixels.
     * Meme chose pour la coordonnee verticale.
     */
    surface_jeu* sprites_ennemis;
    /**
     * Les sprites des projectiles sont organises de la meme maniere que
     * ceux des ennemis.
     */
    surface_jeu* sprites_projectiles;
    /** Barre de vie (pleine et vide) du joueur */
    surface_jeu* barre_vie_joueur;
    /** Barre de vie (pleine et vide) des ennemis */
    surface_jeu* barre_vie_ennemis;
    /** Barre de charge */
    surface_jeu* barre_charge;
    /** Images pour la carte de region */
    surface_jeu* zones_carte_region;
    /** font utilisee */
    font* font_utilisee;
};





/* ================== manipulation des bases_donnees ======================= */

/**
 * \fn struct base_donnees* creer_base_donnees(void)
 * \brief Alloue la memoire necessaire pour une base_donnees
 *
 * \return L'adresse de l'espace memoire alloue
 */
struct base_donnees* creer_base_donnees(void);


/**
 * \fn void remplir_base_donnees(struct base_donnees* donnees)
 * \brief Remplit une struct base_donnees avec ce que l'on peut trouver dans les fichiers appropries
 *
 * \param[out] donnees Un pointeur vers la base de donnees a remplir
 */
void remplir_base_donnees(struct base_donnees* donnees);



/**
 * \fn void detruire_base_donnees(struct base_donnees* donnees)
 * \brief Libere la memoire allouee pour une base_donnee
 *
 *\param donnees Un pointeur vers la base_donnees a detruire
 */
void detruire_base_donnees(struct base_donnees* donnees);



/**
 * \fn void charger_font_titres(struct base_donnees* donnees)
 * \brief Changer la police actuellement utilisee pour mettre celle des titres
 *
 * \param[in,out] donnees Une base de donnees correctement remplie
 *
 * \warning Ne pas se servir de cette fonction avant l'initialisation et
 *          le remplissage de la base_donnees !
 */
void charger_font_titres(struct base_donnees* donnees);



/**
 * \fn void charger_font_defaut(struct base_donnees* donnees)
 * \brief Changer la police actuellement utilisee pour mettre celle par defaut
 *
 * \param[in,out] donnees Une base de donnees correctement remplie
 *
 * \warning Ne pas se servir de cette fonction avant l'initialisation et
 *          le remplissage de la base_donnees !
 */
void charger_font_defaut(struct base_donnees* donnees);



/* =============== accesseurs pour descriptions d'ennemis ================== */

/**
 * \fn unsigned int get_loc_sprites(const struct base_donnees* donnees, const struct ennemi* enn)
 * \brief Obtient la localisation des sprites d'un ennemi donne
 *
 * \param[in] donnees La structure base_donnee dans laquelle on va rechercher
 *               l'information demandee. Elle doit etre correctement remplie
 * \param[in] enn Un pointeur vers l'ennemi auquel on s'interesse
 * \return La localisation des sprites de l'ennemi pointe par enn
 */
unsigned int get_loc_sprites(const struct base_donnees* donnees, const struct ennemi* enn);



/**
 * \fn unsigned int get_pv_max(const struct base_donnees* donnees, const struct ennemi* enn)
 * \brief Obtient les points de vie maximums d'un ennemi donne
 *
 * \param[in] donnees La structure base_donnee dans laquelle on va rechercher
 *               l'information demandee. Elle doit etre correctement remplie
 * \param[in] enn Un pointeur vers l'ennemi auquel on s'interesse
 * \return Les points de vie maximums de l'ennemi pointe par enn
 */
unsigned int get_pv_max(const struct base_donnees* donnees, const struct ennemi* enn);



/**
 * \fn unsigned int get_vit_depl(const struct base_donnees* donnees, const struct ennemi* enn)
 * \brief Obtient la vitesse de deplacement d'un ennemi donne
 *
 * \param[in] donnees La structure base_donnee dans laquelle on va rechercher
 *               l'information demandee. Elle doit etre correctement remplie
 * \param[in] enn Un pointeur vers l'ennemi auquel on s'interesse
 * \return La vitesse de deplacement de l'ennemi pointe par enn
 */
unsigned int get_vit_depl(const struct base_donnees* donnees, const struct ennemi* enn);



/**
 * \fn unsigned int get_puissance(const struct base_donnees* donnees, const struct ennemi* enn)
 * \brief Obtient la puissance d'un ennemi donne
 *
 * \param[in] donnees La structure base_donnee dans laquelle on va rechercher
 *               l'information demandee. Elle doit etre correctement remplie
 * \param[in] enn Un pointeur vers l'ennemi auquel on s'interesse
 * \return La puissance de l'ennemi pointe par enn
 */
unsigned int get_puissance(const struct base_donnees* donnees, const struct ennemi* enn);



/**
 * \fn unsigned int get_vit_charge(const struct base_donnees* donnees, const struct ennemi* enn)
 * \brief Obtient la vitesse de charge d'un ennemi donne
 *
 * \param[in] donnees La structure base_donnee dans laquelle on va rechercher
 *               l'information demandee. Elle doit etre correctement remplie
 * \param[in] enn Un pointeur vers l'ennemi auquel on s'interesse
 * \return La vitesse de charge de l'ennemi pointe par enn
 */
unsigned int get_vit_charge(const struct base_donnees* donnees, const struct ennemi* enn);



/**
 * \fn char* get_nom_ennemi(const struct base_donnees* donnees, const struct ennemi* enn)
 * \brief Obtient le nom d'un ennemi donne
 *
 * \param[in] donnees La structure base_donnee dans laquelle on va rechercher
 *               l'information demandee. Elle doit etre correctement remplie
 * \param[in] enn Un pointeur vers l'ennemi auquel on s'interesse
 * \return Le nom de l'ennemi pointe par enn;
 */
char* get_nom_ennemi(const struct base_donnees* donnees, const struct ennemi* enn);



/**
 * \fn unsigned char get_id_projectile(const struct base_donnees* donnees, const struct ennemi* enn)
 * \brief Obtient l'id des projectiles utilises par un ennemi donne
 *
 * \param[in] donnees La structure base_donnee dans laquelle on va rechercher
 *               l'information demandee. Elle doit etre correctement remplie
 * \param[in] enn Un pointeur vers l'ennemi auquel on s'interesse
 * \return L'id des projectiles utilises par l'ennemi pointe par enn
 */
unsigned char get_id_projectile(const struct base_donnees* donnees, const struct ennemi* enn);



/**
 * \fn unsigned char get_taille(const struct base_donnees* donnees, const struct ennemi* enn)
 * \brief Obtient la taille d'un ennemi donne
 *
 * \param[in] donnees La structure base_donnee dans laquelle on va rechercher
 *               l'information demandee. Elle doit etre correctement remplie
 * \param[in] enn Un pointeur vers l'ennemi auquel on s'interesse
 * \return La taille de l'ennemi pointe par enn
 */
unsigned char get_taille(const struct base_donnees* donnees, const struct ennemi* enn);



/**
 * \fn char get_type_attaque(const struct base_donnees* donnees, const struct ennemi* enn)
 * \brief Obtient le type des attaques lancees par un ennemi donne
 *
 * \param[in] donnees La structure base_donnee dans laquelle on va rechercher
 *               l'information demandee. Elle doit etre correctement remplie
 * \param[in] enn Un pointeur vers l'ennemi auquel on s'interesse
 * \return Le type des attaques lancees par l'ennemi pointe par enn
 * Rappel : on utilise les constantes CONTACT et DISTANCE
 */
char get_type_attaque(const struct base_donnees* donnees, const struct ennemi* enn);



/**
 * \fn char get_stats_vol(const struct base_donnees* donnees, const struct ennemi* enn)
 * \brief Permet de savoir si un ennemi donne vole ou non
 *
 * \param[in] donnees La structure base_donnee dans laquelle on va rechercher
 *               l'information demandee. Elle doit etre correctement remplie
 * \param[in] enn Un pointeur vers l'ennemi auquel on s'interesse
 * \return VRAI si l'ennemi pointe par enn vole, FAUX sinon
 */
char get_stats_vol(const struct base_donnees* donnees, const struct ennemi* enn);



/**
 * \fn unsigned int get_pv_max_par_id(const struct base_donnees* donnees, const unsigned int id_ennemi)
 * \brief Obtient les points de vie maximums d'un ennemi donne
 *
 * \param[in] donnees La structure base_donnee dans laquelle on va rechercher
 *               l'information demandee. Elle doit etre correctement remplie
 * \param[in] id_ennemi L'id de l'ennemi auquel on s'interesse
 * \return Les points de vie maximums de l'ennemi concerne
 */
unsigned int get_pv_max_par_id(const struct base_donnees* donnees, const unsigned int id_ennemi);



/**
 * \fn unsigned int get_vit_depl_par_id(const struct base_donnees* donnees, const unsigned int id_ennemi)
 * \brief Obtient la vitesse de deplacement d'un ennemi donne
 *
 * \param[in] donnees La structure base_donnee dans laquelle on va rechercher
 *               l'information demandee. Elle doit etre correctement remplie
 * \param[in] id_ennemi L'id de l'ennemi auquel on s'interesse
 * \return La vitesse de deplacement de l'ennemi concerne
 */
unsigned int get_vit_depl_par_id(const struct base_donnees* donnees, const unsigned int id_ennemi);



/**
 * \fn unsigned int get_puissance_par_id(const struct base_donnees* donnees, const unsigned int id_ennemi)
 * \brief Obtient la puissance d'un ennemi donne
 *
 * \param[in] donnees La structure base_donnee dans laquelle on va rechercher
 *               l'information demandee. Elle doit etre correctement remplie
 * \param[in] id_ennemi L'id de l'ennemi auquel on s'interesse
 * \return La puissance de l'ennemi concerne
 */
unsigned int get_puissance_par_id(const struct base_donnees* donnees, const unsigned int id_ennemi);



/**
 * \fn unsigned int get_vit_charge_par_id(const struct base_donnees* donnees, const unsigned int id_ennemi)
 * \brief Obtient la vitesse de charge d'un ennemi donne
 *
 * \param[in] donnees La structure base_donnee dans laquelle on va rechercher
 *               l'information demandee. Elle doit etre correctement remplie
 * \param[in] id_ennemi L'id de l'ennemi auquel on s'interesse
 * \return La vitesse de charge de l'ennemi concerne
 */
unsigned int get_vit_charge_par_id(const struct base_donnees* donnees, const unsigned int id_ennemi);



/**
 * \fn char* get_nom_ennemi_par_id(const struct base_donnees* donnees, const unsigned int id_ennemi)
 * \brief Obtient le nom d'un ennemi donne
 *
 * \param[in] donnees La structure base_donnee dans laquelle on va rechercher
 *               l'information demandee. Elle doit etre correctement remplie
 * \param[in] id_ennemi L'id de l'ennemi auquel on s'interesse
 * \return Le nom de l'ennemi concerne;
 */
char* get_nom_ennemi_par_id(const struct base_donnees* donnees, const unsigned int id_ennemi);




/* =============== accesseurs pour descriptions d'objets =================== */

/**
 * \fn char* get_nom_objet(const struct base_donnees* donnees, const unsigned int id)
 * \brief Permet d'obtenir le nom d'un objet a partir de son id

 *
 * \param[in] donnees La structure base_donnee dans laquelle on va rechercher
 *               l'information demandee. Elle doit etre correctement remplie
 * \param[in] id L'id de l'objet concerne (sa position
 *               dans le tableau de la base_donnees)
 * \return L'adresse du premier caractere du nom de l'objet
 */
char* get_nom_objet(const struct base_donnees* donnees, const unsigned int id);



/**
 * \fn char get_type_objet(const struct base_donnees* donnees, const unsigned int id)
 * \brief Permet d'obtenir le type d'un objet a partir de son id
 *
 * \param[in] donnees La structure base_donnee dans laquelle on va rechercher
 *               l'information demandee. Elle doit etre correctement remplie
 * \param[in] id L'id de l'objet concerne (sa position
 *               dans le tableau de la base_donnees)
 * \return Le type de l'objet concerne (voir constantes_et_macros.h)
 */
char get_type_objet(const struct base_donnees* donnees, const unsigned int id);



/**
 * \fn unsigned int get_pv_objet(const struct base_donnees* donnees, const unsigned int id)
 * \brief Permet d'obtenir les pv accordes par un objet a partir de son id
 *
 * \param[in] donnees La structure base_donnee dans laquelle on va rechercher
 *               l'information demandee. Elle doit etre correctement remplie
 * \param[in] id L'id de l'objet concerne (sa position
 *               dans le tableau de la base_donnees)
 * \return Les pv accordes par l'objet concerne
 *
 * Note : Pour connaitre la signification de cette donnee, voir la description
 * du champ pv de la structure description_objet
 */
unsigned int get_pv_objet(const struct base_donnees* donnees, const unsigned int id);



/**
 * \fn unsigned int get_vitesse_deplacement_objet(const struct base_donnees* donnees, const unsigned int id)
 * \brief Permet d'obtenir la vitesse de deplacement octroyee par un objet
 *
 * \param[in] donnees La structure base_donnee dans laquelle on va rechercher
 *               l'information demandee. Elle doit etre correctement remplie
 * \param[in] id L'id de l'objet concerne (sa position
 *               dans le tableau de la base_donnees)
 * \return La vitesse de deplacement octroyee par l'objet concerne
 */
unsigned int get_vitesse_deplacement_objet(const struct base_donnees* donnees, const unsigned int id);



/**
 * \fn unsigned int get_puissance_objet(const struct base_donnees* donnees, const unsigned int id)
 * \brief Permet d'obtenir la puissance octroyee par un objet a partir de son id
 *
 * \param[in] donnees La structure base_donnee dans laquelle on va rechercher
 *               l'information demandee. Elle doit etre correctement remplie
 * \param[in] id L'id de l'objet concerne (sa position
 *               dans le tableau de la base_donnees)
 * \return La puissance octroyee par l'objet concerne
 */
unsigned int get_puissance_objet(const struct base_donnees* donnees, const unsigned int id);



/**
 * \fn unsigned int get_vitesse_charge_objet(const struct base_donnees* donnees, const unsigned int id)
 * \brief Permet d'obtenir la vitesse de charge octroyee par un objet a partir de son id
 *
 * \param[in] donnees La structure base_donnee dans laquelle on va rechercher
 *               l'information demandee. Elle doit etre correctement remplie
 * \param[in] id L'id de l'objet concerne (sa position
 *               dans le tableau de la base_donnees)
 * \return La vitesse de charge octroyee par l'objet concerne
 */
unsigned int get_vitesse_charge_objet(const struct base_donnees* donnees, const unsigned int id);



/**
 * \fn unsigned int get_prix_vente(const struct base_donnees* donnees, const unsigned int id)
 * \brief Permet d'obtenir le prix de vente d'un objet a partir de son id
 *
 * \param[in] donnees La structure base_donnee dans laquelle on va rechercher
 *               l'information demandee. Elle doit etre correctement remplie
 * \param[in] id L'id de l'objet concerne (sa position
 *               dans le tableau de la base_donnees)
 * \return Le prix de vente de l'objet concerne
 *
 * Note : Il ne s'agit pas du prix auquel le joueur peut acheter l'objet,
 * mais de la somme qu'il peut en tirer en le vendant ! Voir la structure
 * description_objet pour plus d'informations
 */
unsigned int get_prix_vente(const struct base_donnees* donnees, const unsigned int id);



/**
 * \fn unsigned int get_prix_achat(const struct base_donnees* donnees, const unsigned int id)
 * \brief Permet d'obtenir le prix d'achat d'un objet a partir de son id
 *
 * \param[in] donnees La structure base_donnee dans laquelle on va rechercher
 *               l'information demandee. Elle doit etre correctement remplie
 * \param[in] id L'id de l'objet concerne (sa position
 *               dans le tableau de la base_donnees)
 * \return Le prix d'achat de l'objet concerne
 *
 * Note : Il ne s'agit pas du prix auquel le joueur peut vendre l'objet !
 * Voir la structure description_objet pour plus d'informations
 */
unsigned int get_prix_achat(const struct base_donnees* donnees, const unsigned int id);



/**
 * \fn unsigned char get_id_projectile_objet(const struct base_donnees* donnees, const unsigned int id)
 * \brief Permet de connaitre le type des projectiles tires par une arme a partir de son id
 *
 * \param[in] donnees La structure base_donnee dans laquelle on va rechercher
 *               l'information demandee. Elle doit etre correctement remplie
 * \param[in] id L'id de l'objet concerne (sa position
 *               dans le tableau de la base_donnees)
 * \return L'id des projectiles utilises par l'arme concernee
 */
unsigned char get_id_projectile_objet(const struct base_donnees* donnees, const unsigned int id);



/* =============== accesseurs pour descriptions de projectiles ================== */



/**
 * \fn unsigned int get_loc_sprites_projectile(const struct base_donnees* donnees, const struct projectile* proj)
 * \brief Obtient la localisation des sprites d'un projectile donne
 *
 * \param[in] donnees Une base_donnees correctement remplie
 * \param[in] proj L'adresse du projectile auquel on s'interesse
 * \return La localisation des sprites (nombre de pixels / 16) du projectile
 */
unsigned int get_loc_sprites_projectile(const struct base_donnees* donnees, const struct projectile* proj);



/**
 * \fn unsigned int get_vitesse_deplacement_projectile(const struct base_donnees* donnees, const struct projectile* proj)
 * \brief Obtient la vitesse de deplacement d'un projectile donne
 *
 * \param[in] donnees Une base_donnees correctement remplie
 * \param[in] proj L'adresse du projectile auquel on s'interesse
 * \return La vitesse de deplacement du projectile
 */
unsigned int get_vitesse_deplacement_projectile(const struct base_donnees* donnees, const struct projectile* proj);



/**
 * \fn unsigned char  get_taille_projectile(const struct base_donnees* donnees, const struct projectile* proj)
 * \brief Obtient la taille d'un projectile donne
 *
 * \param[in] donnees Une base_donnees correctement remplie
 * \param[in] proj L'adresse du projectile auquel on s'interesse
 * \return la taille du projectile (en nombre de cases)
 */
unsigned char  get_taille_projectile(const struct base_donnees* donnees, const struct projectile* proj);



/**
 * \fn unsigned char  get_taille_projectile_par_id(const struct base_donnees* donnees, const unsigned char id)
 * \brief Obtient la taille d'un projectile donne a partir d'un id
 *
 * \param[in] donnees Une base_donnees correctement remplie
 * \param[in] id Un id de projectile
 * \return la taille du projectile (en nombre de cases)
 *
 * Cette fonction est necessaire car on a parfois besoin d'une taille de
 * projectile avant de le creer, par exemple lorsque le joueur tire.
 */
unsigned char  get_taille_projectile_par_id(const struct base_donnees* donnees, const unsigned char id);



/**
 * \fn unsigned int get_vitesse_deplacement_projectile_par_id(const struct base_donnees* donnees,
                                                       const unsigned char id)
 * \brief Obtient la vitesse de deplacement d'un projectile donne
 *
 * \param[in] donnees Une base_donnees correctement remplie
 * \param[in] id L'id du projectile concerne
 * \return La vitesse de deplacement du projectile
 */
unsigned int get_vitesse_deplacement_projectile_par_id(const struct base_donnees* donnees,
                                                       const unsigned char id);



/**
 * \fn void get_drops_par_id(const struct base_donnees* donnees, struct tab_dyn_id** objets,
                             struct tab_dyn_id** probas, const unsigned int id_ennemi)
 * \brief Permet d'obtenir les pointeurs vers les objets laisses par un ennemi
 *        et vers la probabilite de les obtenir a partir d'un id
 *
 * \param[in] donnees Une base_donnees correctement remplie
 * \param[out] objets L'adresse du pointeur que l'on va faire pointer vers les objets
 * \param[out] probas L'adresse du pointeur que l'on va faire pointer vers les taux de probabilite
 * \param[in] id_ennemi L'id de l'ennemi auquel on s'interesse
 */
void get_drops_par_id(const struct base_donnees* donnees, struct tab_dyn_id** objets,
                      struct tab_dyn_id** probas, const unsigned int id_ennemi);



/* =============== experience ============== */

/**
 * \fn unsigned char calculer_niveau(const unsigned int experience, const struct base_donnees* donnees)
 * \brief Donne le niveau du joueur en fonction de son experience
 *
 * \param[in] experience Le total de points d'experience du joueur
 * \param[in] donnees L'adresse d'une base_donnees, dans laquelle on trouve les paliers d'experience
 * \return Le niveau du joueur
 */
unsigned char calculer_niveau(const unsigned int experience, const struct base_donnees* donnees);



/**
 * \fn unsigned int donner_palier_suivant(const unsigned char niveau,
                                          const struct base_donnees* donnees)
 * \brief Donne le nombre de points d'experience a
 *        amasser pour passer au niveau "niveau + 1"
 *
 * \param[in] niveau Le niveau actuel
 * \param[in] donnees L'adresse d'une base_donnees, dans laquelle on trouve les paliers d'experience
 * \return Le nombre de points d'experience a gagner pour passer au niveau suivant
 *
 * \warning Ne pas appeler cette fonction avec niveau = 99,
 *          car il n'y a alors pas de niveau suivant !
 */
unsigned int donner_palier_suivant(const unsigned char niveau,
                                   const struct base_donnees* donnees);


/* =============== quetes ============== */

/**
 * \fn unsigned int get_recompense(const struct base_donnees* donnees,
                                   const unsigned int id_quete)
 * \brief Permet de connaitre l'id de l'objet que l'on obtient
 *        en accomplissant une certaine quete
 *
 * \param[in] donnees L'adresse d'une base de donnees correctement remplie
 * \param[in] id_quete L'id de la quete concernee
 * \return L'id de l'objet que l'on obtient en accomplissant la quete concernee
 */
unsigned int get_recompense(const struct base_donnees* donnees,
                            const unsigned int id_quete);



/**
 * \fn struct objet* get_objets_necessaires(const struct base_donnees* donnees,
                                            const unsigned int id_quete)
 * \brief Permet d'acceder a la liste des objets necessaires d'une quete donnee
 *
 * \param[in] donnees L'adresse d'une base de donnees correctement remplie
 * \param[in] id_quete L'id de la quete concernee
 * \return Un pointeur vers le premier objet de la liste des objets necessaires
 *         pour l'accomplissement de la quete concernee
 */
struct objet* get_objets_necessaires(const struct base_donnees* donnees,
                                     const unsigned int id_quete);


/* =============== regions =============== */

/**
 * \fn const char* get_nom_region(const struct base_donnees* donnees,
                                  const unsigned int id_region)
 * \brief Permet d'obtenir le nom d'une region a partir de son numero
 *
 * \param[in] donnees L'adresse d'une base de donnees correctement remplie
 * \param[in] id_region Le numero de la region
 * \return Le nom de la region
 *
 * Notez qu'il n'y a aucun lien entre la position de la region dans le tableau
 * dynamique des regions contenu dans une base_donnees et son id.
 */
const char* get_nom_region(const struct base_donnees* donnees,
                           const unsigned int id_region);


/**
 * \fn void get_coord_region(const struct base_donnees* donnees,
                             const unsigned int id_region,
                             unsigned int* x,
                             unsigned int* y)
 * \brief Permet d'obtenir les coordonnees d'une region sur la carte du monde
 *
 * \param[in] donnees L'adresse d'une base de donnees correctement remplie
 * \param[in] id_region Le numero de la region concernee
 * \param[out] x Adresse d'un entier positif qui recevra la coordonnee horizontale
 * \param[out] y Adresse d'un entier positif qui recevra la coordonnee verticale
 *
 * Notez qu'il n'y a aucun lien entre la position de la region dans le tableau
 * dynamique des regions contenu dans une base_donnees et son id.
 */
void get_coord_region(const struct base_donnees* donnees,
                      const unsigned int id_region,
                      unsigned int* x,
                      unsigned int* y);



/**
 * \fn const char* get_tout_region(const struct base_donnees* donnees,
                                   const unsigned int id_region,
                                   unsigned int* x,
                                   unsigned int* y)
 * \brief Permet d'obtenir le nom et les coordonnees d'une region
 *
 * \param[in] donnees L'adresse d'une base de donnees correctement remplie
 * \param[in] id_region Le numero de la region concernee
 * \param[out] x Adresse d'un entier positif qui recevra la coordonnee horizontale
 * \param[out] y Adresse d'un entier positif qui recevra la coordonnee verticale
 * \return Le nom de la region
 *
 * Notez qu'il n'y a aucun lien entre la position de la region dans le tableau
 * dynamique des regions contenu dans une base_donnees et son id.
 */
const char* get_tout_region(const struct base_donnees* donnees,
                            const unsigned int id_region,
                            unsigned int* x,
                            unsigned int* y);


#endif /* BASE_DONNEES_H */
